import { NextRequest, NextResponse } from 'next/server';
import { writeFile, mkdir } from 'fs/promises';
import path from 'path';

// 权限验证函数
function checkPermission(request: NextRequest): { hasPermission: boolean; error?: string } {
    const referer = request.headers.get('referer');
    if (!referer) {
        return { hasPermission: false, error: '缺少来源页面信息' };
    }

    try {
        const url = new URL(referer);
        const pathname = url.pathname;

        // 只允许从management页面访问
        if (pathname !== '/management') {
            return { hasPermission: false, error: '权限不足，仅允许从管理页面访问' };
        }

        return { hasPermission: true };
    } catch (error) {
        return { hasPermission: false, error: '无效的来源页面信息' };
    }
}

// 文件名合规校验函数
function validateFileName(name: string): { isValid: boolean; error?: string } {
    // 检查是否为空
    if (!name || name.trim().length === 0) {
        return { isValid: false, error: '文件名不能为空' };
    }

    // 检查长度限制
    if (name.length > 255) {
        return { isValid: false, error: '文件名长度不能超过255个字符' };
    }

    // 检查是否包含非法字符
    const invalidChars = /[<>:"/\\|?*\x00-\x1f]/;
    if (invalidChars.test(name)) {
        return { isValid: false, error: '文件名不能包含以下字符: < > : " / \\ | ? * 以及控制字符' };
    }

    // 检查是否以点开头或结尾
    if (name.startsWith('.') || name.endsWith('.')) {
        return { isValid: false, error: '文件名不能以点开头或结尾' };
    }

    // 检查是否包含连续的点
    if (name.includes('..')) {
        return { isValid: false, error: '文件名不能包含连续的点' };
    }

    // 检查是否为保留名称（Windows 和 Unix 系统）
    const reservedNames = [
        'CON', 'PRN', 'AUX', 'NUL',
        'COM1', 'COM2', 'COM3', 'COM4', 'COM5', 'COM6', 'COM7', 'COM8', 'COM9',
        'LPT1', 'LPT2', 'LPT3', 'LPT4', 'LPT5', 'LPT6', 'LPT7', 'LPT8', 'LPT9'
    ];

    const upperName = name.toUpperCase();
    if (reservedNames.includes(upperName)) {
        return { isValid: false, error: '文件名不能使用系统保留名称' };
    }

    // 检查是否包含空格（可选，根据需求调整）
    if (name.includes(' ')) {
        return { isValid: false, error: '文件名不能包含空格' };
    }

    return { isValid: true };
}

export async function POST(request: NextRequest) {
    try {
        // 权限检查
        const permissionCheck = checkPermission(request);
        if (!permissionCheck.hasPermission) {
            return NextResponse.json(
                { success: false, error: permissionCheck.error },
                { status: 403 }
            );
        }

        const formData = await request.formData();
        const file = formData.get('file') as File;
        const targetPath = formData.get('path') as string || '';

        if (!file) {
            return NextResponse.json(
                { success: false, error: '未提供文件' },
                { status: 400 }
            );
        }

        // 检查文件类型
        const fileName = file.name.toLowerCase();
        if (!fileName.endsWith('.glb') && !fileName.endsWith('.gltf')) {
            return NextResponse.json(
                { success: false, error: '仅支持 .glb 和 .gltf 文件' },
                { status: 400 }
            );
        }

        // 验证文件名
        const validation = validateFileName(file.name);
        if (!validation.isValid) {
            return NextResponse.json(
                { success: false, error: validation.error },
                { status: 400 }
            );
        }

        const baseDir = path.join(process.cwd(), 'storage');
        const uploadDir = path.join(baseDir, targetPath);
        const filePath = path.join(uploadDir, file.name);

        const normalizedFilePath = path.normalize(filePath);
        const normalizedBaseDir = path.normalize(baseDir);

        if (!normalizedFilePath.startsWith(normalizedBaseDir)) {
            return NextResponse.json(
                { success: false, error: '无效的路径' },
                { status: 400 }
            );
        }

        // 确保上传目录存在
        await mkdir(uploadDir, { recursive: true });

        // 检查文件是否已存在
        try {
            const fs = await import('fs/promises');
            await fs.access(filePath);
            return NextResponse.json(
                { success: false, error: '文件已存在' },
                { status: 409 }
            );
        } catch {
            // 文件不存在，可以上传
        }

        // 读取文件内容
        const bytes = await file.arrayBuffer();
        const buffer = Buffer.from(bytes);

        // 写入文件
        await writeFile(filePath, buffer);

        return NextResponse.json({
            success: true,
            fileName: file.name,
            fileSize: file.size,
            path: path.join(targetPath, file.name).replace(/\\/g, '/')
        });
    } catch (error) {
        console.error('Error uploading file:', error);
        return NextResponse.json(
            { success: false, error: '上传文件失败' },
            { status: 500 }
        );
    }
} 